{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: forward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "\n",
    "- 1. input whose absolute value is bigger than 10 (approximately) may lead to this behaviour\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  6.750562121603446e-11\n",
      "dw error:  8.162015570444288e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.52e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 7.98e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "tln_solver_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 2450) loss: 2.302120\n",
      "(Epoch 0 / 10) train acc: 0.123000; val_acc: 0.105000\n",
      "(Iteration 101 / 2450) loss: 1.869038\n",
      "(Iteration 201 / 2450) loss: 1.695074\n",
      "(Epoch 1 / 10) train acc: 0.429000; val_acc: 0.417000\n",
      "(Iteration 301 / 2450) loss: 1.751625\n",
      "(Iteration 401 / 2450) loss: 1.550428\n",
      "(Epoch 2 / 10) train acc: 0.480000; val_acc: 0.438000\n",
      "(Iteration 501 / 2450) loss: 1.493577\n",
      "(Iteration 601 / 2450) loss: 1.537430\n",
      "(Iteration 701 / 2450) loss: 1.515755\n",
      "(Epoch 3 / 10) train acc: 0.493000; val_acc: 0.475000\n",
      "(Iteration 801 / 2450) loss: 1.555335\n",
      "(Iteration 901 / 2450) loss: 1.436184\n",
      "(Epoch 4 / 10) train acc: 0.465000; val_acc: 0.456000\n",
      "(Iteration 1001 / 2450) loss: 1.339564\n",
      "(Iteration 1101 / 2450) loss: 1.492173\n",
      "(Iteration 1201 / 2450) loss: 1.473058\n",
      "(Epoch 5 / 10) train acc: 0.509000; val_acc: 0.481000\n",
      "(Iteration 1301 / 2450) loss: 1.361461\n",
      "(Iteration 1401 / 2450) loss: 1.328086\n",
      "(Epoch 6 / 10) train acc: 0.515000; val_acc: 0.496000\n",
      "(Iteration 1501 / 2450) loss: 1.331289\n",
      "(Iteration 1601 / 2450) loss: 1.315460\n",
      "(Iteration 1701 / 2450) loss: 1.331860\n",
      "(Epoch 7 / 10) train acc: 0.549000; val_acc: 0.503000\n",
      "(Iteration 1801 / 2450) loss: 1.184663\n",
      "(Iteration 1901 / 2450) loss: 1.249771\n",
      "(Epoch 8 / 10) train acc: 0.540000; val_acc: 0.514000\n",
      "(Iteration 2001 / 2450) loss: 1.396100\n",
      "(Iteration 2101 / 2450) loss: 1.210286\n",
      "(Iteration 2201 / 2450) loss: 1.350399\n",
      "(Epoch 9 / 10) train acc: 0.522000; val_acc: 0.508000\n",
      "(Iteration 2301 / 2450) loss: 1.213074\n",
      "(Iteration 2401 / 2450) loss: 1.276241\n",
      "(Epoch 10 / 10) train acc: 0.580000; val_acc: 0.525000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet(hidden_dim=64, reg=1e-3)\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "# NOTE: \n",
    "# 1. data was already stored in the same form that Solver() needs (see the very beginning of FullyConnectedNets.ipynb)\n",
    "# 2. using tuning result obtained in assignment1 for the model.params and solver's hyperparameters \n",
    "solver = Solver(model, data, \n",
    "                update_rule='sgd', \n",
    "                optim_config={\n",
    "                    'learning_rate': 7.5e-4\n",
    "                }, \n",
    "                lr_decay=0.95, \n",
    "                num_epochs=10, batch_size=200, \n",
    "                print_every=100)\n",
    "solver.train()\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less.\n",
    "\n",
    "- 这个gradient checking用了自己实现的forward，万一forward和backward是自洽的，但都是错的怎么办？\n",
    "  - 或者这就要用到下面的sanity check（**overfit checking on small datasets**）\n",
    "  \n",
    "- 能否通过reg=0时Initial_loss=2.3，即约为-log(1/num_classes)来判断forward的准确性？（log是自然对数）\n",
    "\n",
    "\n",
    "- **是否对bias项进行正则化惩罚？（本次实现中没有）**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 3.90e-09\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 2.13e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.57e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  # \n",
    "  # Question: WHY ??\n",
    "  #\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "- can be achieved by setting **weight_scale=1e-2** and **learning_rate=1e-2**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.363364\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.108000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.127000\n",
      "(Epoch 2 / 20) train acc: 0.440000; val_acc: 0.172000\n",
      "(Epoch 3 / 20) train acc: 0.500000; val_acc: 0.184000\n",
      "(Epoch 4 / 20) train acc: 0.540000; val_acc: 0.181000\n",
      "(Epoch 5 / 20) train acc: 0.740000; val_acc: 0.190000\n",
      "(Iteration 11 / 40) loss: 0.839976\n",
      "(Epoch 6 / 20) train acc: 0.740000; val_acc: 0.187000\n",
      "(Epoch 7 / 20) train acc: 0.740000; val_acc: 0.183000\n",
      "(Epoch 8 / 20) train acc: 0.820000; val_acc: 0.177000\n",
      "(Epoch 9 / 20) train acc: 0.860000; val_acc: 0.200000\n",
      "(Epoch 10 / 20) train acc: 0.920000; val_acc: 0.191000\n",
      "(Iteration 21 / 40) loss: 0.337174\n",
      "(Epoch 11 / 20) train acc: 0.960000; val_acc: 0.189000\n",
      "(Epoch 12 / 20) train acc: 0.940000; val_acc: 0.180000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.199000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.199000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.195000\n",
      "(Iteration 31 / 40) loss: 0.075911\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.182000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.201000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.207000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.192000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-2   # Experiment with this!\n",
    "learning_rate = 1e-2  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "- perform **grid search handly !!!!**\n",
    "  - lr_grid=[1, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6]\n",
    "  - std_grid=[1e-1, 1e-2, 1e-3, 1e-4, 1e-5]\n",
    "  - 最后在**lr=1e-3**和**weight_scale=1e-1**下达到过拟合\n",
    "  - 相比3层网络模型，5层网络似乎有点难找，我只找到两个组合：(lr, std)=[(1e-3, 1e-1), (1e-4, 1e-1)]\n",
    "\n",
    "\n",
    "- 两个观察\n",
    "  - 很多lr下改变std无法继续提高train_accurancy（都在0.16左右）\n",
    "  - lr取1e-3或1e-4时，std只在1e-1附近（大概8e-2到1.5e-1）能取得train_acc=1.0，其余std上train_acc居然都是0.16左右\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 54.581332\n",
      "(Epoch 0 / 20) train acc: 0.240000; val_acc: 0.118000\n",
      "(Epoch 1 / 20) train acc: 0.240000; val_acc: 0.082000\n",
      "(Epoch 2 / 20) train acc: 0.300000; val_acc: 0.106000\n",
      "(Epoch 3 / 20) train acc: 0.500000; val_acc: 0.126000\n",
      "(Epoch 4 / 20) train acc: 0.700000; val_acc: 0.140000\n",
      "(Epoch 5 / 20) train acc: 0.840000; val_acc: 0.129000\n",
      "(Iteration 11 / 40) loss: 2.592711\n",
      "(Epoch 6 / 20) train acc: 0.860000; val_acc: 0.124000\n",
      "(Epoch 7 / 20) train acc: 0.880000; val_acc: 0.129000\n",
      "(Epoch 8 / 20) train acc: 0.920000; val_acc: 0.129000\n",
      "(Epoch 9 / 20) train acc: 0.940000; val_acc: 0.126000\n",
      "(Epoch 10 / 20) train acc: 0.960000; val_acc: 0.128000\n",
      "(Iteration 21 / 40) loss: 0.685193\n",
      "(Epoch 11 / 20) train acc: 0.980000; val_acc: 0.128000\n",
      "(Epoch 12 / 20) train acc: 0.980000; val_acc: 0.123000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.130000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.129000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.127000\n",
      "(Iteration 31 / 40) loss: 0.018705\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.127000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.126000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.126000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.126000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.126000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAHDdJREFUeJzt3X+cXHV97/HXu5sAq/xYIAFJEAMWA1iU0C3FG2oRlfBDJbVY0GrTlt6oj2pVvIuJVy3t1RpNK1ofXmqKSFp+XwwBUYw0AblwFdgQIKGY8lPJbiCxsPyQrSThc/843w2bdXdmdmfPnJk57+fjsY+ZOXN+fOZA5j3ne77nexQRmJlZef1G0QWYmVmxHARmZiXnIDAzKzkHgZlZyTkIzMxKzkFgZlZyDgJrWpI6JD0v6ZDJnHcCdXxe0iWTvd4xtvU2SY9VeP8iSZ9uRC1WHlOKLsDah6Tnh718BfArYEd6/cGIuGw864uIHcCekz1vK4uIv6hlPkmbgPdHxC35VmTtwEFgkyYidn4Rp1+1fxER/zbW/JKmRMT2RtRmtfN/l/Jx05A1TGpiuUrSFZKeA94v6U2SfiJpQNJmSf8oaWqaf4qkkDQrvb40vX+jpOck/VjSoeOdN71/qqT/kPSMpK9Lul3Sn9b4OeZLuj/VvEbS7GHvfVpSv6RnJf1U0olp+vGS7k7Tn5S0tMo2zpO0Na3rT4ZNv1TS+en5AZK+n+p4StKtafoVwAzgxtRcdm4NdW+S1CNpPfCCpMWSrhpR04WS/r6WfWStxUFgjfYHwOXAPsBVwHbgY8A0YC5wCvDBCsu/D/gssB/wc+B/jXdeSQcAVwM9abuPAsfVUrykI4FLgY8C04F/A74raaqk16faj42IvYFT03YBvg4sTdN/E7imwmYOBjrJvsw/BFwoae9R5usBHkl1vCp9ViLivUA/cGpE7BkRX6lU97D1nZ1q3gf4V+D0oe1K2g14T5pubcZBYI12W0R8NyJeiojBiLgrIu6IiO0R8QiwDPj9CstfExG9EbENuAw4ZgLzvgO4JyKuS+9dAPyixvrPBq6PiDVp2SXA3sDvkoXaHsDrU/PKo+kzAWwDDpe0f0Q8FxF3VNjGfwGfj4htEXE92bmW140y3zaysDgkIl6MiB9NsO4hX4uITem/yybgx8AfpvdOA/oj4t4K27AW5SCwRnt8+AtJR0j6nqQnJD0L/C3Zr/SxPDHs+QtUPkE81rwzhtcR2ciLm2qofWjZnw1b9qW07MyI2Ah8kuwzbElNYK9Ks/4ZcBSwUdKdkk6rsI1fpJPfo9U+3JJUy2pJD0vqmUjdw+Z5fMQyy4H3p+fvx0cDbctBYI02crjbbwIbgN9MzSafA5RzDZvJml8AkCR2/UKspB94zbBlfyOtqw8gIi6NiLnAoUAH8MU0fWNEnA0cAPwD8B1Je9TzISLi2Yj4RETMAuYDn5I0dDQ1cj9XrHuMZVYAv52avE4la9KzNuQgsKLtBTwD/DK1Y1c6PzBZbgCOlfROSVPIzlFMr3HZq4F3SToxta/3AM8Bd0g6UtJbJO0ODKa/HQCSPiBpWvol/gzZl+5L9XyIVP9rU5A9k7Y1dCTxJHBYLXWPtf6IeAG4FrgCuD0i+saa11qbg8CK9klgAdmX0jfJTiDnKiKeBM4CvgL8J/BaYB1ZW3y1Ze8nq/dCYCvZye13pXb33YEvk51veALYF/hMWvQ04IHUW+rvgbMi4sU6P8psYA3wPHA7WRv/bem9vwP+JvUQ+niVuitZDhyNm4XamnxjGis7SR1kTSdnRsT/LbqeZiLpMOA+4FUR8Xy1+a01+YjASknSKZL2Sc04nyXr8XNnwWU1lXQe4VzgcodAe/OVxVZWJ5B1Kd0NuB+YHxFVm4bKQtI+ZCeSHwPmFVuN5c1NQ2ZmJeemITOzkmuJpqFp06bFrFmzii7DzKylrF279hcRUbVrdEsEwaxZs+jt7S26DDOzliLpZ9XnctOQmVnpOQjMzErOQWBmVnIOAjOzknMQmJmVXEv0GpqIlev6WLpqI/0Dg8zo6qRn3mzmz6l1pGEzs/JoyyBYua6PxSvWM7gtG5G3b2CQxSvWAzgMzMxGaMumoaWrNu4MgSGD23awdNXGgioyM2tebRkE/QOD45puZlZmbRkEM7o6xzXdzKzM2jIIeubNpnNqxy7TOqd20DNvdkEVmZk1r7Y8WTx0Qti9hszMqmvLIIAsDPzFb2ZWXVs2DZmZWe0cBGZmJecgMDMrOQeBmVnJOQjMzErOQWBmVnIOAjOzknMQmJmVnIPAzKzkcr2yWNJjwHPADmB7RHRL2g+4CpgFPAb8UUQ8nWcdZmY2tkYcEbwlIo6JiO70ehGwOiIOB1an12ZmVpAimobOAJan58uB+QXUYGZmSd5BEMAPJa2VtDBNOzAiNgOkxwNGW1DSQkm9knq3bt2ac5lmZuWV9+ijcyOiX9IBwE2SflrrghGxDFgG0N3dHXkVaGZWdrkeEUREf3rcAlwLHAc8KekggPS4Jc8azMysstyCQNIrJe019Bw4GdgAXA8sSLMtAK7LqwYzM6suz6ahA4FrJQ1t5/KI+IGku4CrJZ0D/Bx4T441mJlZFbkFQUQ8ArxxlOn/Cbw1r+2amdn4+MpiM7OSa9t7Ftdr5bo+lq7aSP/AIDO6OumZN9v3QDaztuQgGMXKdX0sXrGewW07AOgbGGTxivUADgMzaztuGhrF0lUbd4bAkMFtO1i6amNBFZmZ5cdBMIr+gcFxTTcza2UOglHM6Ooc13Qzs1bmIBhFz7zZdE7t2GVa59QOeubNLqgiM7P8+GTxKIZOCLvXkJmVgYNgDPPnzPQXv5mVgpuGzMxKzkFgZlZyDgIzs5JzEJiZlZyDwMys5BwEZmYl5yAwMys5B4GZWck5CMzMSs5BYGZWcg4CM7OScxCYmZWcg8DMrOQcBGZmJecgMDMrOQeBmVnJOQjMzErOQWBmVnK5B4GkDknrJN2QXh8q6Q5JD0q6StJueddgZmZja8QRwceAB4a9/hJwQUQcDjwNnNOAGszMbAy5BoGkg4HTgYvSawEnAdekWZYD8/OswczMKsv7iOCrwHnAS+n1/sBARGxPrzcBM0dbUNJCSb2Serdu3ZpzmWZm5ZVbEEh6B7AlItYOnzzKrDHa8hGxLCK6I6J7+vTpudRoZmYwJcd1zwXeJek0YA9gb7IjhC5JU9JRwcFAf441mJlZFbkdEUTE4og4OCJmAWcDayLij4GbgTPTbAuA6/KqwczMqiviOoJPAedKeojsnMG3CqjBzMySPJuGdoqIW4Bb0vNHgOMasV0zM6vOVxabmZWcg8DMrOQcBGZmJecgMDMrOQeBmVnJOQjMzErOQWBmVnIOAjOzknMQmJmVnIPAzKzkxhUEyrwyr2LMzKzxqgaBpH+RtLekVwD3A49KOjf/0szMrBFqOSI4OiKeJbul5A/J7iHwp3kWZWZmjVNLEOwmaQpwBrAyIl7k5VtPmplZi6slCC4Cfg7sC/xI0iHA87lWZWZmDVM1CCLigoiYEREnR0QAjwMn5V+amZk1Qi0niz8iae/0/JvAHcDv5V2YmZk1Ri1NQwsj4llJJwMzgQ8DX863LDMza5RagiDS46nAtyNibY3LmZlZC6jlC/1eSd8H3gncKGlPXg4HMzNrcbXcvP7PgN8GHoqIFyRNA87JtywzM2uUqkEQETvSl/+7JQH8KCJuzL0yMzNriFp6DX0BOA94JP31SPp83oWZmVlj1NI09E7g2IjYDiDpYuBu4DN5FmZmZo1Ra++fvcZ4bmZmLa6WI4IvA3dLWg0IOBH4XJ5FmZlZ49RysvhSSTcDv0sWBJ+LiL7cKzMzs4YYMwgkvWHEpIfS4/6S9o+I+yqtWNIewK3A7mk710TEX0s6FLgS2I/sXMMH0oimZmZWgEpHBN+o8F4Ab66y7l8BJ0XE85KmArdJuhE4F7ggIq6U9E9k1yRcOJ6izcxs8owZBBFR18ByaaTSoeGqp6a/IBu59H1p+nLgfBwEZmaFyXXMIEkdku4BtgA3AQ8DA0NdUYFNZAPZjbbsQkm9knq3bt2aZ5lmZqVWS6+hCYuIHcAxkrqAa4EjR5ttjGWXAcsAuru7J31so5Xr+li6aiP9A4PM6OqkZ95s5s8ZNZPMzNparkEwJCIGJN0CHA90SZqSjgoOBvobUcNwK9f1sXjFega37QCgb2CQxSvWAzgMzKx0ahli4g2j/L1GUsVlJU1PRwJI6gTeBjwA3AycmWZbAFxX30cYv6WrNu4MgSGD23awdNXGRpdiZla4Wo4IvgUcA9xPdh3BkcAGYB9JCyNi9RjLHQQsl9RBFjhXR8QNkv4duDKNV7Qurb+h+gcGxzXdzKyd1RIEDwLnDF03IOlo4BPA3wHXkIXEr0nzzxll+iPAcRMteDLM6Oqkb5Qv/RldnQVUY2ZWrFp6DR05/OKxiFhPNgjdQxWWaWo982bTObVjl2mdUzvomTe7oIrMzIpTyxHBw5K+TnY1MMBZwEOSdge2j71Y8xo6IexeQ2ZmoOy6rwozSK8APgqcQHaO4Dbg68B/AXtGxDN5F9nd3R29vb15b8bMrK1IWhsR3dXmq2XQuReAL6W/kXIPATMzy1fVIJB0PPDXwGuGzx8Rr8uxLjMza5BazhF8m+xWlWuBHVXmNTOzFlNLEDwbEd/NvRIzMytELUGwRtIXgRVkQ0sDO68TMDOzFldLEJww4hFqux+BmZm1gFp6DdV1XwIzM2tulW5V+d6IuELSX432fkT8Y35lmZlZo1Q6Itg3PU5vRCFmZlaMSreq/N/p8bONK8fMzBqtlgvKpgF/Dsxi1wvKFuZXVnPz3c3MrJ3U0mvoOuAnZGMMlf6CMt/dzMzaTS1B8MqI+GTulbSISnc3cxCYWSuq5X4EN0o6OfdKWoTvbmZm7aaWIPgQ8ANJz0t6StLTkp7Ku7BmNdZdzHx3MzNrVbUEwTRgKrAPWVfSaZS4S6nvbmZm7abSBWWHR8SDwOvHmKWUYw357mZm1m4qnSxeBJwDfGOU90o91tD8OTP9xW9mbaPSBWXnpEePNWRm1sZq6T6KpCOAo4A9hqZFxOV5FWVmZo1Ty5XFnwFOBo4AVgHzyC4ucxCYmbWBWnoNnQW8BdgcER8A3kiNRxJmZtb8agmCwYjYAWyXtBfwBHBYvmWZmVmj1PLLfp2kLuBioBd4Frg716rMzKxhKgaBJAHnR8QA8A1Jq4C9I6JqEEh6NfAvwKuAl4BlEfE1SfsBV5GNZvoY8EcR8XRdn8LMzCasYtNQRARww7DXD9USAsl24JMRcSRwPPCXko4iuz5hdUQcDqxOr83MrCC1nCO4U9Kx411xRGweCo2IeA54AJgJnAEsT7MtB+aPd91mZjZ5Kg0xMSUitgMnAP9d0sPALwGRHSzUHA6SZgFzgDuAAyNiM9lKNks6YIxlFgILAQ455JBaN2VmZuNU6RzBncCx1PmLXdKewHeAj0fEs9lph+oiYhmwDKC7uzvqqcHMzMZWKQgEEBEPT3TlkqaShcBlEbEiTX5S0kHpaOAgYMtE129mZvWrFATTJZ071psR8ZVKK049jr4FPDBi3uuBBcCS9Hhd7eWamdlkqxQEHcCepCODCZgLfABYL+meNO3TZAFwtaRzgJ8D75ng+s3MbBJUCoLNEfG3E11xRNzG2CHy1omu18zMJlel7qMTPRIwM7MWUikI/KvdzKwExgyCiCjtDerNzMqkliuLzcysjTkIzMxKzkFgZlZyDgIzs5JzEJiZlZyDwMys5BwEZmYl5yAwMys5B4GZWck5CMzMSs5BYGZWcg4CM7OScxCYmZWcg8DMrOQcBGZmJecgMDMrOQeBmVnJOQjMzErOQWBmVnIOAjOzknMQmJmV3JSiCyijlev6WLpqI/0Dg8zo6qRn3mzmz5lZdFlmVlIOggZbua6PxSvWM7htBwB9A4MsXrEewGFgZoVw01CDLV21cWcIDBnctoOlqzYWVJGZlZ2DoMH6BwbHNd3MLG+5BYGkiyVtkbRh2LT9JN0k6cH0uG9e229WM7o6xzXdzCxveR4RXAKcMmLaImB1RBwOrE6vS6Vn3mw6p3bsMq1zagc982YXVJGZlV1uJ4sj4lZJs0ZMPgM4MT1fDtwCfCqvGopSqVfQ0KN7DZlZs2h0r6EDI2IzQERslnTAWDNKWggsBDjkkEMaVF79aukVNH/OTH/xm1nTaNqTxRGxLCK6I6J7+vTpRZdTM/cKMrNW0+ggeFLSQQDpcUuDt5879woys1bT6CC4HliQni8Armvw9nPnXkFm1mry7D56BfBjYLakTZLOAZYAb5f0IPD29LqtuFeQmbWaPHsNvXeMt96a1zabgXsFmVmr8VhDOXCvIDNrJU3ba8jMzBrDQWBmVnIOAjOzknMQmJmVnIPAzKzkHARmZiXnIDAzKzkHgZlZyTkIzMxKzkFgZlZyDgIzs5JzEJiZlZyDwMys5BwEZmYl5yAwMys534+gCa1c1+cb25hZwzgImszKdX0sXrGewW07AOgbGGTxivUADgMzy4WDoMksXbVxZwgMGdy2g6WrNjYkCPI8GvGRjllzchA0mf6BwXFNn0x5Ho34SMeseflkcZOZ0dU5runjtXJdH3OXrOHQRd9j7pI1rFzXt/O9Skcj9cpz3WZWHwdBk+mZN5vOqR27TOuc2kHPvNl1r3voV3nfwCDBy7/Kh8Igz6ORIo90zKwyB0GTmT9nJl9899HM7OpEwMyuTr747qMnpfmk2q/yPI9G8j7SMbOJ8zmCJjR/zsxc2s2r/SrvmTd7l3Z8mLyjkTzXbWb1cRC0oIn2vpnR1UnfKGEw9Kt8aB159OzJc93NwD2irJUpIoquoaru7u7o7e0tuoymMLL3DWS/rIeajyp9IVVbttbtV/rCK+MXYi37tYz7xYonaW1EdFebz0cELaZaO3+lLpr1/iqv1gW03i6i9X5Z5hlSlZatdu3HZHSdrRbwDhmrRyFHBJJOAb4GdAAXRcSSSvP7iOBlhy76HqP9FxNjN/3M7Ork9kUn1b3tuUvWVFx/tfcrqfdXdS1HShNdf7VlK/03eXTJ6TXtl4l+NqDuo5E83y9y2+1cW62a9ohAUgfwDeDtwCbgLknXR8S/N7qWVlSpnT/vLprV1l/P9uv9VV1t+XrWX23Zaudequ2Xej7b0POJ7rc834fKR6iubWK15aGI7qPHAQ9FxCMR8SJwJXBGAXW0pErXGeTdRbPa+uvZfrUvy2pfhvWGVKX119LbqtK1H9X2Sz2frd79luf7RW67nWvLQxFBMBN4fNjrTWnaLiQtlNQrqXfr1q0NK67ZVbrOIM+L0aD6F14926/2ZVntC6/ekKq0/mrLVrv2o9p+qeez1bvf8ny/yG23c215KCIINMq0X2tijYhlEdEdEd3Tp09vQFmtY/6cmdy+6CQeXXI6ty86aecXTp4Xo9Wy/nq2X++v6npDqtL6awm4sf6bDL1Xab/U89nq3W95vl/kttu5tjwUEQSbgFcPe30w0F9AHW2p0hdSI9Y/0e3X+6u63pCqtP7JCNhK+6Wez1bvfsvz/SK33c615aHhvYYkTQH+A3gr0AfcBbwvIu4faxn3GjLIv5tkkd0wixz+2z1zWq+2WtXaa6io7qOnAV8l6z56cUR8odL8DgIzs/Fr2u6jABHxfeD7RWzbzMx25dFHzcxKzkFgZlZyDgIzs5JzEJiZlVxLDEMtaSvwswkuPg34xSSWM5lc28S4tolxbRPTyrW9JiKqXpHbEkFQD0m9tXSfKoJrmxjXNjGubWLKUJubhszMSs5BYGZWcmUIgmVFF1CBa5sY1zYxrm1i2r62tj9HYGZmlZXhiMDMzCpwEJiZlVxbB4GkUyRtlPSQpEVF1zOcpMckrZd0j6RCh1aVdLGkLZI2DJu2n6SbJD2YHvdtotrOl9SX9t09aTTbImp7taSbJT0g6X5JH0vTC993FWorfN9J2kPSnZLuTbX9TZp+qKQ70n67StJuTVTbJZIeHbbfjml0bamODknrJN2QXk/OPouItvwjG+L6YeAwYDfgXuCoousaVt9jwLSi60i1vBk4FtgwbNqXgUXp+SLgS01U2/nA/2iC/XYQcGx6vhfZfTaOaoZ9V6G2wvcd2V0K90zPpwJ3AMcDVwNnp+n/BHy4iWq7BDizCf6fOxe4HLghvZ6UfdbORwTHAQ9FxCMR8SJwJXBGwTU1pYi4FXhqxOQzgOXp+XJgfkOLSsaorSlExOaIuDs9fw54gOz+24Xvuwq1FS4yz6eXU9NfACcB16TpRe23sWornKSDgdOBi9JrMUn7rJ2DYCbw+LDXm2iSfwhJAD+UtFbSwqKLGcWBEbEZsi8V4ICC6xnpI5LuS01HhTRbDSdpFjCH7BdkU+27EbVBE+y71MRxD7AFuIns6H0gIranWQr79zqytogY2m9fSPvtAkm7F1DaV4HzgJfS6/2ZpH3WzkGgUaY1RbIncyPiWOBU4C8lvbnoglrIhcBrgWOAzcA/FFmMpD2B7wAfj4hni6xlpFFqa4p9FxE7IuIYsnuWHwccOdpsja0qbXREbZJ+C1gMHAH8DrAf8KlG1iTpHcCWiFg7fPIos05on7VzEGwCXj3s9cFAf0G1/JqI6E+PW4Bryf4xNJMnJR0EkB63FFzPThHxZPrH+hLwzxS47yRNJfuivSwiVqTJTbHvRqutmfZdqmcAuIWsHb4r3dMcmuDf67DaTklNbRERvwK+TeP321zgXZIeI2vmPonsCGFS9lk7B8FdwOHprPpuwNnA9QXXBICkV0raa+g5cDKwofJSDXc9sCA9XwBcV2Atuxj6kk3+gIL2XWqj/RbwQER8Zdhbhe+7sWprhn0nabqkrvS8E3gb2TmMm4Ez02xF7bfRavvpsGAXWTt8Q/dbRCyOiIMjYhbZd9maiPhjJmufFX0WPM8/4DSy3hIPA/+z6HqG1XUYWS+me4H7i64NuIKsmWAb2ZHUOWTtj6uBB9Pjfk1U278C64H7yL50DyqothPIDsXvA+5Jf6c1w76rUFvh+w54A7Au1bAB+FyafhhwJ/AQ8H+A3ZuotjVpv20ALiX1LCro/7sTebnX0KTsMw8xYWZWcu3cNGRmZjVwEJiZlZyDwMys5BwEZmYl5yAwMys5B4GViqTn0+MsSe+b5HV/esTr/zeZ6zfLi4PAymoWMK4gkNRRZZZdgiAi/ts4azIrhIPAymoJ8HtpbPlPpIHGlkq6Kw0s9kEASSemcf0vJ7ugCEkr02CB9w8NGChpCdCZ1ndZmjZ09KG07g3K7kFx1rB13yLpGkk/lXRZunLVrKGmVJ/FrC0tIhuX/x0A6Qv9mYj4nTSy5O2SfpjmPQ74rYh4NL3+84h4Kg1BcJek70TEIkkfiWywspHeTTbI2xuBaWmZW9N7c4DXk40RczvZmDK3Tf7HNRubjwjMMicDf5KGH76DbJiIw9N7dw4LAYC/knQv8BOygQ0Pp7ITgCsiG+ztSeBHZKNYDq17U2SDwN1D1mRl1lA+IjDLCPhoRKzaZaJ0IvDLEa/fBrwpIl6QdAuwRw3rHsuvhj3fgf9NWgF8RGBl9RzZLRyHrAI+nIZuRtLr0siwI+0DPJ1C4Aiy4ZOHbBtafoRbgbPSeYjpZLffvHNSPoXZJPCvDyur+4DtqYnnEuBrZM0yd6cTtlsZ/bZ/PwA+JOk+YCNZ89CQZcB9ku6ObIjgIdcCbyIbbTaA8yLiiRQkZoXz6KNmZiXnpiEzs5JzEJiZlZyDwMys5BwEZmYl5yAwMys5B4GZWck5CMzMSu7/AxkpG030O7wAAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 1e-3  # Experiment with this!\n",
    "weight_scale = 8e-2   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "\n",
    "- 根据上一栏的观察，或许这就是默认网络是3层的原因！这个网络对初始配置没那么敏感（**5层网络对初始化值很敏感！**）\n",
    "- 若没有这一问提示，我还真想不到这茬orz\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.559978\n",
      "(Epoch 0 / 5) train acc: 0.104000; val_acc: 0.107000\n",
      "(Iteration 11 / 200) loss: 2.356069\n",
      "(Iteration 21 / 200) loss: 2.214091\n",
      "(Iteration 31 / 200) loss: 2.205928\n",
      "(Epoch 1 / 5) train acc: 0.225000; val_acc: 0.193000\n",
      "(Iteration 41 / 200) loss: 2.132095\n",
      "(Iteration 51 / 200) loss: 2.118950\n",
      "(Iteration 61 / 200) loss: 2.116443\n",
      "(Iteration 71 / 200) loss: 2.132549\n",
      "(Epoch 2 / 5) train acc: 0.298000; val_acc: 0.260000\n",
      "(Iteration 81 / 200) loss: 1.977227\n",
      "(Iteration 91 / 200) loss: 2.007528\n",
      "(Iteration 101 / 200) loss: 2.004762\n",
      "(Iteration 111 / 200) loss: 1.885342\n",
      "(Epoch 3 / 5) train acc: 0.343000; val_acc: 0.287000\n",
      "(Iteration 121 / 200) loss: 1.891516\n",
      "(Iteration 131 / 200) loss: 1.923677\n",
      "(Iteration 141 / 200) loss: 1.957743\n",
      "(Iteration 151 / 200) loss: 1.966736\n",
      "(Epoch 4 / 5) train acc: 0.322000; val_acc: 0.305000\n",
      "(Iteration 161 / 200) loss: 1.801483\n",
      "(Iteration 171 / 200) loss: 1.973779\n",
      "(Iteration 181 / 200) loss: 1.666572\n",
      "(Iteration 191 / 200) loss: 1.909494\n",
      "(Epoch 5 / 5) train acc: 0.372000; val_acc: 0.319000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 3.153778\n",
      "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.088000\n",
      "(Iteration 11 / 200) loss: 2.227203\n",
      "(Iteration 21 / 200) loss: 2.125706\n",
      "(Iteration 31 / 200) loss: 1.932679\n",
      "(Epoch 1 / 5) train acc: 0.308000; val_acc: 0.258000\n",
      "(Iteration 41 / 200) loss: 1.946330\n",
      "(Iteration 51 / 200) loss: 1.780463\n",
      "(Iteration 61 / 200) loss: 1.753502\n",
      "(Iteration 71 / 200) loss: 1.844626\n",
      "(Epoch 2 / 5) train acc: 0.377000; val_acc: 0.331000\n",
      "(Iteration 81 / 200) loss: 2.028390\n",
      "(Iteration 91 / 200) loss: 1.685415\n",
      "(Iteration 101 / 200) loss: 1.513205\n",
      "(Iteration 111 / 200) loss: 1.431671\n",
      "(Epoch 3 / 5) train acc: 0.469000; val_acc: 0.335000\n",
      "(Iteration 121 / 200) loss: 1.678510\n",
      "(Iteration 131 / 200) loss: 1.545243\n",
      "(Iteration 141 / 200) loss: 1.616405\n",
      "(Iteration 151 / 200) loss: 1.676435\n",
      "(Epoch 4 / 5) train acc: 0.489000; val_acc: 0.351000\n",
      "(Iteration 161 / 200) loss: 1.442014\n",
      "(Iteration 171 / 200) loss: 1.375687\n",
      "(Iteration 181 / 200) loss: 1.344824\n",
      "(Iteration 191 / 200) loss: 1.337178\n",
      "(Epoch 5 / 5) train acc: 0.513000; val_acc: 0.345000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda3\\lib\\site-packages\\matplotlib\\figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "    print('running with ', update_rule)\n",
    "    model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=5, batch_size=100,\n",
    "                    update_rule=update_rule,\n",
    "                    optim_config={\n",
    "                      'learning_rate': 5e-3,\n",
    "                    },\n",
    "                    verbose=True)\n",
    "    solvers[update_rule] = solver\n",
    "    solver.train()\n",
    "    print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "    plt.subplot(3, 1, 1)\n",
    "    plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "    \n",
    "    plt.subplot(3, 1, 2)\n",
    "    plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "    plt.subplot(3, 1, 3)\n",
    "    plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "\n",
    "for i in [1, 2, 3]:\n",
    "    plt.subplot(3, 1, i)\n",
    "    plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  0.0015218451757856217\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))            # may be something wrong in ADAM\n",
    "                                                                       # but I cannot figure it out ... orz\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.476928\n",
      "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.110000\n",
      "(Iteration 11 / 200) loss: 2.027712\n",
      "(Iteration 21 / 200) loss: 2.183358\n",
      "(Iteration 31 / 200) loss: 1.744257\n",
      "(Epoch 1 / 5) train acc: 0.363000; val_acc: 0.330000\n",
      "(Iteration 41 / 200) loss: 1.707951\n",
      "(Iteration 51 / 200) loss: 1.703835\n",
      "(Iteration 61 / 200) loss: 2.094758\n",
      "(Iteration 71 / 200) loss: 1.505558\n",
      "(Epoch 2 / 5) train acc: 0.419000; val_acc: 0.362000\n",
      "(Iteration 81 / 200) loss: 1.594429\n",
      "(Iteration 91 / 200) loss: 1.519017\n",
      "(Iteration 101 / 200) loss: 1.368523\n",
      "(Iteration 111 / 200) loss: 1.470400\n",
      "(Epoch 3 / 5) train acc: 0.460000; val_acc: 0.378000\n",
      "(Iteration 121 / 200) loss: 1.199064\n",
      "(Iteration 131 / 200) loss: 1.464705\n",
      "(Iteration 141 / 200) loss: 1.359863\n",
      "(Iteration 151 / 200) loss: 1.415069\n",
      "(Epoch 4 / 5) train acc: 0.521000; val_acc: 0.374000\n",
      "(Iteration 161 / 200) loss: 1.382818\n",
      "(Iteration 171 / 200) loss: 1.359900\n",
      "(Iteration 181 / 200) loss: 1.095948\n",
      "(Iteration 191 / 200) loss: 1.243087\n",
      "(Epoch 5 / 5) train acc: 0.572000; val_acc: 0.382000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.589166\n",
      "(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000\n",
      "(Iteration 11 / 200) loss: 2.032921\n",
      "(Iteration 21 / 200) loss: 1.897277\n",
      "(Iteration 31 / 200) loss: 1.770793\n",
      "(Epoch 1 / 5) train acc: 0.381000; val_acc: 0.320000\n",
      "(Iteration 41 / 200) loss: 1.895731\n",
      "(Iteration 51 / 200) loss: 1.681091\n",
      "(Iteration 61 / 200) loss: 1.487204\n",
      "(Iteration 71 / 200) loss: 1.629973\n",
      "(Epoch 2 / 5) train acc: 0.429000; val_acc: 0.350000\n",
      "(Iteration 81 / 200) loss: 1.506686\n",
      "(Iteration 91 / 200) loss: 1.610742\n",
      "(Iteration 101 / 200) loss: 1.486124\n",
      "(Iteration 111 / 200) loss: 1.559454\n",
      "(Epoch 3 / 5) train acc: 0.492000; val_acc: 0.359000\n",
      "(Iteration 121 / 200) loss: 1.496859\n",
      "(Iteration 131 / 200) loss: 1.531552\n",
      "(Iteration 141 / 200) loss: 1.550195\n",
      "(Iteration 151 / 200) loss: 1.657838\n",
      "(Epoch 4 / 5) train acc: 0.533000; val_acc: 0.354000\n",
      "(Iteration 161 / 200) loss: 1.603105\n",
      "(Iteration 171 / 200) loss: 1.408064\n",
      "(Iteration 181 / 200) loss: 1.504707\n",
      "(Iteration 191 / 200) loss: 1.385212\n",
      "(Epoch 5 / 5) train acc: 0.528000; val_acc: 0.370000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
